home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / db / esm-3.1 / esm-3 / usr / local / sm / src / include / BTREEPAGE.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-05  |  15.1 KB  |  601 lines
  1. #ifndef __BTREEPAGE_H__
  2. #define __BTREEPAGE_H__
  3. /*
  4.  * $RCSfile: BTREEPAGE.h,v $
  5.  * $Revision: 1.1.1.1 $
  6.  * $Date: 1996/05/04 21:55:07 $
  7.  */
  8. /**********************************************************************
  9.  * EXODUS Database Toolkit Software
  10.  * Copyright (c) 1991 Computer Sciences Department, University of
  11.  *                    Wisconsin -- Madison
  12.  * All Rights Reserved.
  13.  *
  14.  * Permission to use, copy, modify and distribute this software and its
  15.  * documentation is hereby granted, provided that both the copyright
  16.  * notice and this permission notice appear in all copies of the
  17.  * software, derivative works or modified versions, and any portions
  18.  * thereof, and that both notices appear in supporting documentation.
  19.  *
  20.  * THE COMPUTER SCIENCES DEPARTMENT OF THE UNIVERSITY OF WISCONSIN --
  21.  * MADISON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION.  
  22.  * THE DEPARTMENT DISCLAIMS ANY LIABILITY OF ANY KIND FOR ANY DAMAGES
  23.  * WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  24.  *
  25.  * The EXODUS Project Group requests users of this software to return 
  26.  * any improvements or extensions that they make to:
  27.  *
  28.  *   EXODUS Project Group 
  29.  *     c/o David J. DeWitt and Michael J. Carey
  30.  *   Computer Sciences Department
  31.  *   University of Wisconsin -- Madison
  32.  *   Madison, WI 53706
  33.  *
  34.  *     or exodus@cs.wisc.edu
  35.  *
  36.  * In addition, the EXODUS Project Group requests that users grant the 
  37.  * Computer Sciences Department rights to redistribute these changes.
  38.  **********************************************************************/
  39.  
  40. #include <stdio.h>
  41. #include <stdlib.h>
  42.  
  43. #ifdef SERVER_MAKE
  44. #   include <sys/types.h>
  45. #   include <netinet/in.h>
  46. #   include <setjmp.h>
  47. #   include "sysdefs.h"
  48. #endif SERVER_MAKE
  49.  
  50. #include "ess.h"
  51. #include "checking.h"
  52. #include "trace.h"
  53. #include "error.h"
  54. #include "io.h"
  55. #include "list.h"
  56. #include "object.h"
  57. #include "tid.h"
  58. #include "lock.h"
  59.  
  60. #ifdef SERVER_MAKE
  61. #    include "msgdefs.h"
  62. #    include "thread.h"
  63. #    include "semaphore.h"
  64. #    include "latch.h"
  65. #    include "pool.h"
  66. #    include "link.h"
  67. #endif SERVER_MAKE
  68.  
  69. #include "bf.h"
  70.  
  71. #ifndef SERVER_MAKE
  72. #    include "chunk.h" 
  73. #    include "load.h"
  74. #    include "scan.h"
  75. #    include "sm_params.h"
  76. #    include "btree.h"
  77. #    include "sm_globals.h"
  78. #    include "sm_extfuncs.h"
  79. #    include "sm_state.h"
  80. #endif SERVER_MAKE
  81.  
  82. #include "bf_extfuncs.h"
  83. #include "bf_globals.h"
  84. #include "cc_macro.h"
  85. #include "volume.h"
  86. #include "lsn.h"
  87. #include "logrecs.h"
  88. #include "logaction.h"
  89. #include "trans.h"
  90. #ifndef SERVER_MAKE
  91. #    include "clog.h"
  92. #    include "clog_extfuncs.h"
  93. #    include "loginfo.h"
  94. #    include "clog_globals.h"
  95. #else
  96. #    include "trans_extfuncs.h"
  97. #    include "openlog.h"
  98. #    include "log.h"
  99. #    include "log_extfuncs.h"
  100. #    include "thread_globals.h"
  101. #    include "undo.h"
  102. #    include "undo_extfuncs.h"
  103. #    include "redo_extfuncs.h"
  104. #    include "log_globals.h"
  105. #endif SERVER_MAKE
  106.  
  107. #ifndef PFCDEFINED
  108. typedef int     (*PFC)(int kLen1, void* kVal1, int kLen2, void* kVal2);
  109. typedef void    (*PFK)(int kLen, char* kVal);
  110. #endif    /* PFCDEFINED */
  111.  
  112. #ifdef __ESS_H__
  113. #define ASSERT1(cond)    SM_ASSERT(LEVEL_1, cond)
  114. #define ASSERT2(cond)    SM_ASSERT(LEVEL_2, cond)
  115. #define ASSERT3(cond)    SM_ASSERT(LEVEL_3, cond)
  116. #endif
  117.  
  118.  
  119. #include "bt_extfuncs.h"
  120.  
  121. /*
  122.  *    Size of a BTREEPAGE defined in object.h
  123.  */
  124.  
  125. #ifdef __cplusplus            /* BTREEPAGE defs for C++ only */
  126.  
  127. const MAXINT = (1 << 31) - 1;
  128.  
  129. //
  130. // This should be an external function in BF layer.
  131. //
  132. extern "C" PAGEHASH* BF_FindHashEntry(PID*);
  133.  
  134.  
  135. //
  136. //    BT_TRACE macro
  137. //
  138. #ifdef BT_DEBUG
  139. #define BT_TRACE(x)    printf x
  140. #else
  141. #define BT_TRACE(x)
  142. #endif
  143.  
  144.  
  145. //
  146. //    Maximum # of levels
  147. //
  148. const MAXPARENTS = 10;
  149.  
  150. const EMPTYSLOT    = -1;
  151.  
  152.  
  153. enum BT_OPER  {
  154.     BT_READ = 1,
  155.     BT_INSERT = 2,
  156.     BT_DELETE = 4,
  157.     BT_INSERT_DELETE = 6
  158. };
  159.  
  160.  
  161. // 
  162. //    BTREE page control structure 
  163. //
  164. struct BTCONTROL { 
  165.     LRC        lrc;        // for recovery (MUST BE 1st FIELD (cheated))
  166.     PID        selfID;        // id of this page
  167.     TWO        endData;    // offset to end of the data section 
  168.     TWO        numOffsets;    // number of offsets 
  169.     TWO        numFree;    // number of free bytes 
  170.     UONE    level;        // leaf if 1, non-leaf if > 1
  171.     ONE        type;        // SMDATATYPE
  172.     SHORTPID     next;        // left sibling
  173.     SHORTPID     prev;        // right sibling
  174.     SHORTPID     pid0;        // first ptr in non-leaf nodes
  175.     FOUR    filler;        // for 8byte alignment
  176. };
  177.  
  178.  
  179. const BT_MAGIC = 14021967;
  180.  
  181. /*
  182.  *     BTREE page definition
  183.  */
  184. const BT_DATASIZE = BTREE_PAGESIZE - sizeof(BTCONTROL);
  185.  
  186. struct BT_Tuple;
  187.  
  188. typedef TWO SLOT;
  189.  
  190. class BTREEPAGE {
  191.     
  192.     // 
  193.     //    Physical undos and redos must access page directly
  194.     //    (special _fr functions are used to bypass a g++ bug)
  195.     //
  196.     friend void undoBtree_fr(LOGRECORDHDR*);
  197.     friend void redoBtree_fr(LOGRECORDHDR*);
  198.     
  199. protected:
  200.     
  201.     BTCONTROL    btCtrl;        // control information
  202.     char    data[BT_DATASIZE - sizeof(SLOT)];
  203.     SLOT    slot[1];    // first slot on page
  204.     
  205.     void Compress();
  206.     
  207. public:
  208.     /*
  209.      *    General queries
  210.      */
  211.     LRC&     lrc()        { return btCtrl.lrc; }
  212.     PID&    SelfID()    { return btCtrl.selfID; }
  213.     int        Level()        { return btCtrl.level; }
  214.     SHORTPID    NextPage()    { return btCtrl.next; }
  215.     SHORTPID    PrevPage()    { return btCtrl.prev; }
  216.     int        Volume()    { return btCtrl.selfID.volid; }
  217.     SHORTPID    FirstVector()    { return btCtrl.pid0; }
  218.     int        NumSlots()    { return btCtrl.numOffsets; }
  219.     int        IsLeaf()    { return btCtrl.level == 1; }
  220.     int        IsNode()    { return ! IsLeaf(); }
  221.     SMDATATYPE    KeyType()    { return (SMDATATYPE) btCtrl.type; }
  222.     IsSafe(BT_OPER oper, int maxKeyLen);
  223.     
  224.     /*
  225.      *    Space usage 
  226.      */
  227.     UsableSpace()    { 
  228.     return BT_DATASIZE - btCtrl.endData 
  229.         - (btCtrl.numOffsets * sizeof(slot[0]));
  230.     }
  231.     UsedSpace()        { return BT_DATASIZE - btCtrl.numFree; }
  232.     FreeSpace()        { return btCtrl.numFree; }
  233.     
  234.     /*
  235.      *    Modify internal states
  236.      */
  237.     void SetFirstVector(SHORTPID pid)    { btCtrl.pid0 = pid; }
  238.     void SetLevel(int level)        { btCtrl.level = level; }
  239.     void Linkup(BTREEPAGE* rightPage, BTREEPAGE* rightRightPage);
  240.     
  241.     /*
  242.      *    Return a reference to tuple in slot sNum
  243.      */
  244.     BT_Tuple& Tuple(int sNum);
  245.     
  246.     /*
  247.      *    Add/Remove an element to/from slot sNum
  248.      */
  249.     AddElem(int sNum, const void* elem);
  250.     RemoveElem(int sNum, const void* elem);
  251.  
  252.     /*
  253.      *    Search for keyVal and, if found, return the slot in retSlot.
  254.      *    Returns TRUE if found, FALSE otherwise.
  255.      */
  256.     Search(int keyLen, const void* keyVal, PFC compFunc, TWO& retSlot);
  257.     
  258.     /*
  259.      *    Insert/Remove a tuple into/from slot "slotNum"
  260.      */
  261.     void AppendTuple(BT_Tuple& tuple)     {
  262.     InsertTuple(tuple, NumSlots());
  263.     }
  264.     void InsertTuple(BT_Tuple& tuple, int slotNum);
  265.     
  266.     void RemoveTuple(int slotNum);
  267.     
  268.     /*
  269.      *    Move numTuples starting at slotNum to destSlot in destPage
  270.      */
  271.     void ShiftTuple(int slotNum, BTREEPAGE* destPage, 
  272.             int destSlot, int numTuples);
  273.     
  274.     /*
  275.      *    Set tuple to overflow (reclaim space used by oidList)
  276.      */
  277.     void SetOverflow(int slotNum, const PID& ovPid);
  278.     
  279.     /*
  280.      *    Set tuple to underflow (reinsert oidList)
  281.      */
  282.     void SetUnderflow(int slotNum, int oidCnt, const void* elList);
  283.     
  284.     //
  285.     //    Copy data and data usage indicators to target page
  286.     //
  287.     void CopyData(BTREEPAGE* target);
  288.     
  289.     //
  290.     //    Initialize a new page
  291.     //
  292.     void Init(const PID& pid, int level, SMDATATYPE keyType);
  293.     
  294.     //
  295.     //    Debugging utilities
  296.     //
  297.     CheckContent();
  298.     
  299.     void
  300.     Print(BUFGROUP* bufGroup);
  301. };
  302.  
  303. #if (defined DEBUG && defined btree_MODULE) || ! defined DEBUG
  304.  
  305. INLINE BT_Tuple& BTREEPAGE::Tuple(int sNum)
  306. { 
  307.     return *((BT_Tuple*)(data+slot[-sNum])); 
  308. }
  309.  
  310. #endif /* (DEBUG && btree_MODULE) || !DEBUG */
  311.  
  312.  
  313. class ParentStack;
  314. class SMOPages;
  315. class OVPAGE;
  316.  
  317. class LHINDPAGE;
  318. class LHDIRPAGE;
  319.  
  320. //
  321. // REMEMBER: change GetPage() to call appropriate bf_ routine when it
  322. //     is available. GetPage() should allocate a page in the buffer
  323. //     without reading it from the server. It is called when the
  324. //     program needs a page right after allocating it.
  325. //
  326. struct PageDesc {
  327.     GROUPLINK*     gLink;
  328.     
  329.     //
  330.     //    Implicit conversion operators
  331.     //
  332.     operator BTREEPAGE*()    { 
  333.     return (gLink) ? (BTREEPAGE*) gLink->bufFrame : 0;
  334.     }
  335.     operator OVPAGE*()        {
  336.     return (gLink) ? (OVPAGE*) gLink->bufFrame : 0;
  337.     }
  338.     operator LHINDPAGE*()   {
  339.     return (gLink) ? (LHINDPAGE*) gLink->bufFrame : 0;
  340.     }
  341.     operator LHDIRPAGE*()   {
  342.     return (gLink) ? (LHDIRPAGE*) gLink->bufFrame : 0; 
  343.     }
  344.     
  345.     operator GROUPLINK*()    { return gLink; }
  346.     operator PAGEHASH*()    { return gLink->pageHash; }
  347.     operator ==(PageDesc& pd)     { return pd.gLink == gLink; }
  348.     
  349.     int  Read(BUFGROUP* bfg, const PID& pid, LOCKMODE lockMode);
  350.     int     GetPage(BUFGROUP* bfg, const PID& pid);
  351.     void Force();
  352.     void Dirty();
  353.     void Unfix();
  354.     void UnfixDirty();
  355.     void UnfixUnlock();
  356.     void UnfixUnlockDirty();
  357.     PageDesc()                { gLink = 0; }
  358.     ~PageDesc()                { };
  359. };
  360.  
  361.  
  362.  
  363. #ifdef SERVER_MAKE
  364. inline int PageDesc::Read(BUFGROUP* bfg, const PID& pid, LOCKMODE )
  365. {
  366.     SM_ASSERT(LEVEL_1, (gLink == 0));
  367.     gLink = bf_ReadPage(bfg, &pid, BTREE_PAGE2SIZE, NOFLAGS);
  368.     return (gLink) ? esmNOERROR : esmFAILURE;
  369. }
  370.  
  371. inline int PageDesc::GetPage(BUFGROUP* bfg, const PID& pid)    
  372. {
  373.     // really read the page, do not use the NOREAD flag
  374.     SM_ASSERT(LEVEL_1, (gLink == 0));
  375.     gLink = bf_ReadPage(bfg, &pid, BTREE_PAGE2SIZE, NOFLAGS);
  376.     return (gLink) ? esmNOERROR : esmFAILURE;
  377. }
  378. inline void PageDesc::Force()
  379. { 
  380. }
  381. inline void PageDesc::Dirty()
  382. { 
  383.     DIRTY_PAGE(gLink->pageHash);
  384. }
  385. inline void PageDesc::Unfix()
  386. { 
  387.     SM_ASSERT(LEVEL_1, gLink != 0);
  388.     bf_UnfixPage(gLink, BF_DEFAULT, FALSE); 
  389.     gLink = 0; 
  390. }
  391. inline void PageDesc::UnfixDirty()
  392. { 
  393.     SM_ASSERT(LEVEL_1, gLink != 0);
  394.     bf_UnfixPage(gLink, BF_DEFAULT, TRUE); 
  395.     gLink = 0; 
  396. }
  397. inline void PageDesc::UnfixUnlock()
  398. { 
  399.     Unfix();
  400. }
  401. inline void PageDesc::UnfixUnlockDirty()
  402. {
  403.     UnfixDirty();
  404. }
  405.  
  406. #else
  407. inline int PageDesc::Read(BUFGROUP* bfg, const PID& pid, LOCKMODE lockMode)
  408. {
  409.  
  410.     SM_ASSERT(LEVEL_1, (gLink == 0));
  411.     gLink = bf_ReadPage(bfg, &pid, H_INDEX, BTREE_PAGE2SIZE, lockMode);
  412.     return (gLink) ? esmNOERROR : esmFAILURE;
  413. }
  414.  
  415. inline int PageDesc::GetPage(BUFGROUP* bfg, const PID& pid)
  416. {
  417.     SM_ASSERT(LEVEL_1, (gLink == 0));
  418.     gLink = bf_FakeReadPage(bfg, &pid, H_INDEX, BTREE_PAGE2SIZE);
  419.     return (gLink) ? esmNOERROR : esmFAILURE;
  420. }
  421.  
  422. inline void PageDesc::Force()
  423. { 
  424.     bf_ForcePage(gLink->pageHash, NOFLAGS); 
  425. }
  426. inline void PageDesc::Dirty()
  427. { 
  428.     bf_DirtyPage(gLink->pageHash); 
  429. }
  430. inline void PageDesc::Unfix()
  431. { 
  432.     SM_ASSERT(LEVEL_1, gLink != 0);
  433.     bf_UnfixPage(gLink, BF_LRU, FALSE); 
  434.     gLink = 0; 
  435. }
  436. inline void PageDesc::UnfixDirty()
  437. {
  438.     SM_ASSERT(LEVEL_1, gLink != 0);
  439.     bf_UnfixPage(gLink, BF_LRU, TRUE); 
  440.     gLink = 0;
  441. }
  442. inline void PageDesc::UnfixUnlock()
  443. { 
  444.     SM_ASSERT(LEVEL_1, gLink != 0);
  445.     bf_UnfixUnlockPage(gLink, BF_LRU, FALSE); 
  446.     gLink = 0;
  447. }
  448. inline void PageDesc::UnfixUnlockDirty()
  449. {
  450.     SM_ASSERT(LEVEL_1, gLink != 0);
  451.     bf_UnfixUnlockPage(gLink, BF_LRU, TRUE); 
  452.     gLink = 0;
  453. }
  454.  
  455. #endif
  456.  
  457.  
  458. #include "BT_Tuple.h"
  459.  
  460.  
  461. #ifndef SERVER_MAKE
  462. extern BOOL btLogActive;    // true if log should be generated
  463. extern BOOL btCLRLogActive;    // true if CLR log should be generated during SMO
  464. #endif
  465.  
  466. extern "C"  {
  467.     extern int BT_AllocPage(
  468.     TID tid, int volume, BUFGROUP* bufGroup,
  469.     PID& returnPid, TWO level, SMDATATYPE keyType);
  470.     extern int BT_Traverse(
  471.     const PID& rootPid, int keyLen, const void* keyVal, 
  472.     int& found, TWO& returnSlot, ParentStack& pl,
  473.     BT_OPER oper, int maxKeyLen, PFC compFunc);
  474.     extern int BT_SplitPage(
  475.     TID tid, BUFGROUP* bufGroup, SMOPages* smo, 
  476.     ParentStack& pl, TWO slot,
  477.     int length, PageDesc& rightLink);
  478.     extern int BT_NewNodeTuple(
  479.     TID tid, BUFGROUP* bufGroup, SMOPages* smo,
  480.     ParentStack& pl, TWO klen,
  481.     void* key, PID* subtreePid, PFC compFunc);
  482.     extern int BT_ShiftTuples(
  483.     BTREEPAGE* srcPage, int srcSlot,
  484.     BTREEPAGE* destPage, int destSlot, 
  485.     int numTuples);
  486.     extern int BT_SearchElemArray(
  487.     int elSize, const void* el, int elCnt, 
  488.     const char* elArray, int& idx);
  489.     
  490.     extern int BT_LastEntry(
  491.     const PID& rootPID, int& found, 
  492.     TWO& slot, ParentStack& pl);
  493.     extern int BT_FirstEntry(
  494.     const PID& rootPID, int& found,
  495.     TWO& slot, ParentStack& pl);
  496.     
  497.     extern int BT_DecrElCnt(
  498.     TID tid, const PID& rootPid, BUFGROUP* bufGroup,
  499.     void* key, int keyLen, int maxKeyLen, 
  500.     PFC compFunc, LSNOFFSET undoNxtLSN);
  501.     extern int BT_IncrElCnt(
  502.     TID tid, const PID& rootPid, BUFGROUP* bufGroup,
  503.     void* key, int keyLen, int maxKeyLen, 
  504.     PFC compFunc, LSNOFFSET undoNxtLSN);
  505.     extern int BT_SetOverflow(
  506.     TID tid, const PID& rootPid, 
  507.     BUFGROUP* bufGroup, void* key, int keyLen, 
  508.     int maxKeyLen, PFC compFunc, const void* elList, 
  509.     int numOid, LSNOFFSET undoNxtLSN);
  510.     extern int BT_ResetOverflow(
  511.     TID tid, const PID& rootPid, 
  512.     BUFGROUP* bufGroup, void* key, int keyLen, 
  513.     int maxKeyLen, PFC compFunc, 
  514.     const void* elList, 
  515.     int numOid, LSNOFFSET undoNxtLSN);
  516.     
  517.     extern int BT_SetCLR(TID tid);
  518.     extern int BT_SetAnchor(TID tid);
  519.     extern int BT_ElemDiff(int sz, const void* e1, const void* e2);
  520.     
  521.     extern void BT_LogPageInit(PAGEHASH* pHash,TWO level, SMDATATYPE keyType);
  522.     extern void BT_LogModifyLink(
  523.     PID&, PAGEHASH* pHash, LRC&,
  524.     SHORTPID oldNext, SHORTPID newNext,
  525.     SHORTPID oldPrev, SHORTPID newPrev, 
  526.     LSNOFFSET undoNxtLSN);
  527.     extern void BT_LogModifyVector0(
  528.     PID&, PAGEHASH*, LRC&, SHORTPID oldPid0, 
  529.     SHORTPID newPid0, LSNOFFSET undoNxtLSN);
  530.     extern void BT_LogModifyLevel(
  531.     PID&, PAGEHASH*, LRC&, TWO oldLevel, 
  532.     TWO newLevel, LSNOFFSET undoNxtLSN); 
  533.     extern void BT_LogLogicInsert(
  534.     PID&, PAGEHASH*, LRC&, const PID& rootPid, 
  535.     const void* key, TWO keyLen, 
  536.     const void* el, TWO elSize,
  537.     TWO maxKeyLen, TWO unique, 
  538.     SMDATATYPE keyType,
  539.     LSNOFFSET undoNxtLSN);
  540.     extern void BT_LogLogicDelete(
  541.     PID&, PAGEHASH*, LRC&, const PID& rootPid, 
  542.     const void* key, 
  543.     TWO keyLen, const void* el, TWO elSize,
  544.     TWO maxKeyLen, TWO unique, SMDATATYPE keyType,
  545.     LSNOFFSET undoNxtLSN);
  546.     extern void BT_LogLogicSetOverflow(
  547.     PID&, PAGEHASH*, LRC&, 
  548.     const PID& rootPid, 
  549.     const void* key, TWO keyLen, TWO maxKeyLen,
  550.     SMDATATYPE keyType, int numEl, int elSize,
  551.     const void* elList, const PID& ovRoot,
  552.     LSNOFFSET undoNxtLSN);
  553.     extern void BT_LogLogicResetOverflow(
  554.     PID&, PAGEHASH*, LRC&, 
  555.     const PID& rootPid, 
  556.     const void* key, TWO keyLen, TWO maxKeyLen,
  557.     SMDATATYPE keyType, int numEl, int elSize,
  558.     const void* elList, const PID& ovRoot,
  559.     LSNOFFSET undoNxtLSN);
  560.     extern void BT_LogLogicIncrElCnt(
  561.     PID&, PAGEHASH*, LRC&, 
  562.     const PID& rootPid, 
  563.     const void* key, TWO keyLen, TWO maxKeyLen,
  564.     SMDATATYPE keyType, LSNOFFSET undoNxtLSN);
  565.     extern void BT_LogLogicDecrElCnt(
  566.     PID&, PAGEHASH*, LRC&, 
  567.     const PID& rootPid, 
  568.     const void*key, TWO keyLen, TWO maxKeyLen,
  569.     SMDATATYPE keyType, LSNOFFSET undoNxtLSN);
  570.  
  571.  
  572. #ifdef SERVER_MAKE
  573.     extern void BT_LogPureCLR(LSNOFFSET);
  574. #endif
  575. }
  576.  
  577. extern void BT_LogPhysicInsert(
  578.     PID&, PAGEHASH*, LRC&,
  579.     TWO slotNum, TWO numSlot, LSNOFFSET undoNxtLSN);
  580. extern void BT_LogPhysicDelete(
  581.     PID&, PAGEHASH*, LRC&, 
  582.     TWO slotNum, TWO numSlot, LSNOFFSET undoNxtLSN);
  583.  
  584. #ifdef SERVER_MAKE
  585. extern void BT_LogPhysicInsert(
  586.     PID&, PAGEHASH*, LRC&, TWO slotNum, 
  587.     TWO numSlot, int length, void* p, LSNOFFSET undoNxtLSN);
  588. extern void BT_LogPhysicDelete(
  589.     PID&, PAGEHASH*, LRC&, TWO slotNum, 
  590.     TWO numSlot, int length, void* p, LSNOFFSET undoNxtLSN);
  591. #endif
  592.  
  593. #include "LHINDPAGE.h"
  594. #include "LHDIRPAGE.h"
  595.  
  596. #endif        /* #ifdef C++ */
  597.  
  598. #endif __BTREEPAGE_H__
  599.  
  600.  
  601.